function test(): void {
  return;
};

export function test(): void {
  return;
};

export var fn = function (): number {
  return 1;
};

export var arrowFn = (): string => 'test';

export class Test {
  constructor(one: string) {}
  get prop(one: string): void {
    return 1;
  }
  set prop(one: string): void {}
  method(one: string): void {
    return;
  }
  arrow = (one: string): string => 'arrow';
  abstract abs(one: string): void;
};

export class Test {
  constructor();
  constructor(value?: string) {
    console.log(value);
  }
};

const test = (): void => {
  return;
};
export default test;

function test(): void {
  return;
}
export default test;

const test = (): void => {
  return;
};
export default [test];

function test(): void {
  return;
}
export default [test];

const test = (): void => {
  return;
};
export default { test };

function test(): void {
  return;
}
export default { test };

const foo = (arg => arg) as Foo;
export default foo;

let foo = (arg => arg) as Foo;
foo = 3;
export default foo;

class Foo {
  bar = (arg: string): string => arg;
}
export default { Foo };

class Foo {
  bar(): void {
    return;
  }
}
export default { Foo };

export function foo(): (n: number) => string {
  return n => String(n); 
};

export const foo = (a: string): ((n: number) => string) => {
  return function (n) {
    return String(n);
  };
};

export function fn() {
  return function (): void {};
};

export function foo(outer: string) {
  return function (inner: string): void {};
}

export function foo(arg = 1): void {};

export const foo = (): ((n: number) => string) => n => String(n);

export function foo(): (n: number) => (m: number) => string {
  return function (n) {
    return function (m) {
      return String(n + m);
    };
  };
};

export const foo = (): ((n: number) => (m: number) => string) => n => m =>
String(n + m);

export abstract class Foo<T> {
  abstract set value(element: T);
};

export declare class Foo {
  set time(seconds: number);
};

export class A {
  b = A;
};

interface Foo {
  f: (x: boolean) => boolean;
}
export const a: Foo[] = [
  {
    f: (x: boolean) => x,
  },
];

interface Foo1 {
  f: (x: boolean) => boolean;
}
export const a: Foo = {
  f: (x: boolean) => x,
};